suma::Num a => a -> a -> a
suma x y = x + y


-- 	Practica 0:
--               Ejercicio 2:
--a
valorAbsoluto :: (Num a, Ord a) => a -> a
valorAbsoluto a = if (a < 0) then (-a) else a

--b
bisiesto::Integer -> Bool
bisiesto n = if ((((n `mod` 4) == 0) && ((n `mod` 100) /= 0)) 
		||
		(((n `mod` 100) == 0) && ((n `mod` 400) == 0))) 
		then True 
		else False


-- c:
factorial::Integer -> Integer
factorial 0 = 1
factorial n = n * factorial(n-1)

--              Ejercicio 3:
-- a
inverso :: Float -> Maybe Float
inverso 0 = Nothing
inverso n = Just (1/n)

--b
aEntero :: Either Int Bool -> Int
aEntero (Left n) 	= n
aEntero (Right True) 	= 1
aEntero (Right False) 	= 0

--              Ejercicio 4:
-- a: que elimina todas las apariciones de cualquier car ́cter de la primera cadena en la segunda.

limpiar :: String -> String -> String
limpiar xs ys = [z| z <- ys, noEsta z xs]

noEsta :: Eq a => a -> [a] -> Bool
noEsta a [] 	= True
noEsta a (x:xs) = if (a==x) then False else noEsta a xs

--b que dada una lista de números devuelve la diferencia de cada uno con el promedio general.
sumaLista::Num a => [a] -> a
sumaLista = foldr (+) 0

promedio :: [Float] -> Float
promedio xs = (sumaLista xs) / (fromIntegral (length xs))


difPromedio :: [Float] -> [Float]
difPromedio xs = map (\x -> (x - (promedio xs))) xs


-- c :que indica si una lista de enteros tiene todos sus elementos iguales.
todosIguales :: [Int] -> Bool
todosIguales [] 	= True
todosIguales [x] 	= True
todosIguales (x:y:xs) 	= foldr (\z c -> c&& z==x) True (y:xs)



data AB a = Nil | Bin (AB a) a (AB a)

nullTree :: AB a-> Bool
nullTree Nil = True
nullTree _ = False

negTree :: AB Bool -> AB Bool
negTree Nil = Nil
negTree (Bin izq a der) = Bin (negTree izq) (not a) (negTree der)

booltree = (Bin ( Bin ( Bin ( Bin (Nil) (True) (Nil)) (False) (Nil)) (False) (Nil)) (True) ( Bin (Nil) (False) (Nil)))

intTree = (Bin ( Bin ( Bin ( Bin (Nil) (2) (Nil)) (3) (Nil)) (2) (Nil)) (7) ( Bin (Nil) (5) (Nil)))


prodTree :: AB Integer ->Integer
prodTree Nil = 1
prodTree (Bin izq a der) = a * prodTree(izq) * prodTree(der)

